class Scene3DTileset {
  constructor() {}
  /**
   * @brief Cesium倾斜，3DTiles,白膜数据调整透明度，明亮度，对比度等
   * @author 轩
   * @param {Object} model 需要进行改变的倾斜
   * @param {Float} initContrast 对比度初始值，比如：1.0
   * @param {Float} initSaturation 饱和度初始值，比如：1.0
   * @param {Float} initBrightness 明亮度初始值，比如：1.0
   */
  adjustModelStyle(
    model,
    initContrast = 1.0,
    initSaturation = 1.0,
    initBrightness = 1.0
  ) {
    if (model && model instanceof Cesium.Cesium3DTileset) {
      model.customShader = new Cesium.CustomShader({
        uniforms: {
          contrast: {
            type: Cesium.UniformType.FLOAT,
            //修改该参数，调整倾斜模型的对比度
            value: initContrast
          },
          saturation: {
            type: Cesium.UniformType.FLOAT,
            //修改该参数，调整倾斜模型的饱和度
            value: initSaturation
          },
          brightness: {
            type: Cesium.UniformType.FLOAT,
            //修改该参数，调整倾斜模型的明暗度
            value: initBrightness
          }
        },
        fragmentShaderText: `
                    vec3 rgbToHsv(vec3 rgb) {
                        float cmax = max(max(rgb.r, rgb.g), rgb.b);
                        float cmin = min(min(rgb.r, rgb.g), rgb.b);
                        float delta = cmax - cmin;
  
                        vec3 hsv = vec3(0.0);
  
                        // 计算 Hue
                        if (delta == 0.0) {
                            hsv.x = 0.0;
                        } else if (cmax == rgb.r) {
                            hsv.x = mod((rgb.g - rgb.b) / delta, 6.0);
                        } else if (cmax == rgb.g) {
                            hsv.x = ((rgb.b - rgb.r) / delta) + 2.0;
                        } else {
                            hsv.x = ((rgb.r - rgb.g) / delta) + 4.0;
                        }
                            hsv.x /= 6.0;
  
                            // 计算 Saturation
                        if (cmax == 0.0) {
                            hsv.y = 0.0;
                        } else {
                            hsv.y = delta / cmax;
                        }
  
                            // 计算 Value
                        hsv.z = cmax;
  
                        return hsv;
                        }
  
                    vec3 hsvToRgb(vec3 hsv) {
                        vec3 rgb = vec3(0.0);
  
                        float c = hsv.z * hsv.y;
                        float x = c * (1.0 - abs(mod(hsv.x * 6.0, 2.0) - 1.0));
                        float m = hsv.z - c;
  
                        if (hsv.x < 1.0/6.0) {
                            rgb = vec3(c, x, 0.0);
                        } else if (hsv.x < 2.0/6.0) {
                            rgb = vec3(x, c, 0.0);
                        } else if (hsv.x < 3.0/6.0) {
                            rgb = vec3(0.0, c, x);
                        } else if (hsv.x < 4.0/6.0) {
                            rgb = vec3(0.0, x, c);
                        } else if (hsv.x < 5.0/6.0) {
                            rgb = vec3(x, 0.0, c);
                        } else {
                            rgb = vec3(c, 0.0, x);
                        }
  
                            rgb += m;
  
                            return rgb;
                        }
  
                    void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material) {
                        vec3 color = czm_gammaCorrect(material.diffuse);  // 获取当前像素的颜色并进行 gamma 矫正
  
                        // 调整对比度
                        color = (color - vec3(0.5)) * contrast + vec3(0.5);
  
                        // 调整饱和度
                        //float saturation = 3.0;  // 饱和度增加因子，可以根据需要调整
                        vec3 hsv = rgbToHsv(color);
                        hsv.y *= saturation;
                        color = hsvToRgb(hsv);
  
                        // 调整亮度
                        //float brightness = 3.;  // 亮度增加因子，可以根据需要调整
                        color *= brightness;
  
                        material.diffuse = czm_gammaCorrect(color);  // 将调整后的颜色再次 gamma 矫正并设置为材质的颜色
                }
                `
      });
    }
  }

  /**
   * @brief glb模型点击高亮闪烁
   * @author 轩
   * @param {Object} entity Cesium中添加的实体
   * @param {Boolean} enable 开启还是关闭高亮闪烁
   */
  addHightLight(entity, enable = false) {
    if (!Cesium.defined(entity) || enable == false) {
      if (entity) {
        entity.model.customShader = undefined;
      }
      return;
    }

    if (!Boolean(entity.model.customShader)) {
      entity.model.customShader = new Cesium.CustomShader({
        uniforms: {
          u_enable: {
            value: enable,
            type: Cesium.UniformType.BOOL
          }
        },

        fragmentShaderText: `
          void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material) {
              float time = fract(czm_frameNumber / 50.0);
              time = abs(time - 0.5) * 2.0; // 生成一个从0到1再回到0的值
              vec3 lightColor = vec3(1.0, 0.8, 0.6); // 可以根据需要调整
              lightColor = czm_saturation(lightColor, 2.0); // 增加饱和度 (1.0为原始饱和度)
  
              float brightness = 10.0; // 增加亮度 (1.0为原始亮度)
              lightColor *= brightness;
  
                 if(u_enable){
                      material.diffuse = material.diffuse * lightColor * time;
                 }
                     
                 
  
            
          }
      `
      });
    }
  }
}
export default Scene3DTileset;
